﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GestionePolveri2.DAL;
using GestionePolveriLib.BL;
using LinqKit;
using FrameworkLib.Facades;
using FrameworkLib.Filters;
using System.Data.Objects;


namespace GestionePolveriLib.Facades
{
    public enum LottoLoadingModes
    {
        NotAssociated = 0,
        Associated,
        All,
        Different
    }

    public class LottoFacade : FacadeBase<GestionePolveriEntities>
    {


        GestionePolveriEntities context = null;

        public LottoFacade()
        {
            context = this.GetContext();
        }

        public LottoFacade(string connectionString)
        {
            context = this.GetContext(connectionString);
        }

        public void LoadAsync(BackgroundWorkerCallbackBase.Callback callback)
        {
            this.RunAsync(() => GetLotti(), callback);
        }

        public void LoadAsync(BackgroundWorkerCallbackBase.Callback callback, LottoLoadingModes loadingMode)
        {
            this.RunAsync(() => GetLotti(loadingMode), callback, loadingMode);
        }

        public void LoadAsync(BackgroundWorkerCallbackBase.Callback callback, long idPolvere)
        {
            this.RunAsync(() => GetLotti(idPolvere), callback, idPolvere);
        }

        public void LoadAsyncAll(BackgroundWorkerCallbackBase.Callback callback, long idPolvere)
        {
            this.RunAsync(() => GetLottiAll(idPolvere), callback, idPolvere);
        }

        //public void LoadAsyncNulli(BackgroundWorkerCallbackBase.Callback callback, long idPolvere)
        //{
        //    this.RunAsync(() => GetLottiNulli(idPolvere), callback, idPolvere);
        //}

        public List<Lotto> GetLotti(LottoLoadingModes loadingMode)
        {
            // metodo non  utilizzato - non ho aggiunto tipo=1
            List<Lotto> retValue = null;

            var predicate = PredicateBuilder.True<Lotti>();

            switch (loadingMode)
            {
                case LottoLoadingModes.NotAssociated:
                    {
                        //predicate = PredicateBuilder.And<Lotti>(l => (l.NumFattura == null), l => (l.DataFattura == null));
                        //predicate = predicate.And(l => (l.NumFattura == null) && (l.DataFattura == null));
                        predicate = predicate.And(l => (l.NumFattura == null || l.NumFattura == ""));
                    }
                    break;
                case LottoLoadingModes.Associated:
                    {
                        //predicate = PredicateBuilder.And<Lotti>(l => (l.NumDdt != null), l => (l.DataDdt != null));
                        //predicate = predicate.And(l => (l.NumFattura != null) && (l.DataFattura != null));
                        predicate = predicate.And(l => (l.NumFattura != null && l.NumFattura != ""));
                    }
                    break;
                case LottoLoadingModes.All:
                    break;
                default:
                    break;
            }

            try
            {
                var obj = from x in context.Lotti.AsExpandable().Where(predicate)
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto> GetLotti(FilterBase<Lotti> filter)
        {
            //

            List<Lotto> retValue = null;

            try
            {
                //where (x.IDPolvere == idpolvere && x.Giacenza > 0)
                //where x.Giacenza != 0 && x.IDPolvere == idpolvere
                var obj = from x in context.Lotti.AsExpandable().Where(filter.SetUpFilter())
                          //where x.Giacenza > 0
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura.Value
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto> GetLotti(long idpolvere)
        {
            //fatto
            List<Lotto> retValue = null;
            try
            {
                //where (x.IDPolvere == idpolvere && x.Giacenza > 0)
                //where x.Giacenza != 0 && x.IDPolvere == idpolvere
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Giacenza != 0
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto> GetLottiNulli(long idpolvere)
        {
            //fatto
            List<Lotto> retValue = null;
            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Giacenza == 0
                          orderby x.DataDdt, x.Giacenza ascending
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLottiAllineamento(long idpolvere)
        {
            //(non nulli e attivi)
            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          //where x.IDPolvere == idpolvere && x.Giacenza != 0 && x.Tipo==1
                          where x.IDPolvere == idpolvere && x.Giacenza != 0
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura,
                              IsLottoNC = (x.LottiNC == null ? false : true),
                              IsLottoBlocked = (x.LottiNC == null ? false : x.LottiNC.FlagBlocco),
                              NoteNC = (x.LottiNC == null ? string.Empty : x.LottiNC.Note)
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLottiAllineamentoNonAttivi(long idpolvere)
        {
            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Tipo == 0
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLottiAllineamentoNulli(long idpolvere)
        {
            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Giacenza == 0
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLotti_NulliNA(long idpolvere)
        {

            //+ nulli + non attivi
            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLotti_NA(long idpolvere)
        {
            // + non attivi (non nulli)

            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Giacenza != 0
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto2> GetLotti_Nulli(long idpolvere)
        {

            //+  nulli (attivi)
            List<Lotto2> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          //where x.IDPolvere == idpolvere  && x.Tipo==1
                          where x.IDPolvere == idpolvere
                          orderby x.DataDdt
                          select new Lotto2
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.PrezzoUnitario * x.Giacenza,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              IDFormato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.IDFormato).FirstOrDefault(),
                              Formato = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Formato).FirstOrDefault(),
                              Pezzatura = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.FormatoScatole.Pezzatura).FirstOrDefault(),
                              DataControllo = x.DataControllo,
                              Tipo = (Lotto.TipoLotto)x.Tipo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura,
                              IsLottoNC = (x.LottiNC == null ? false : true),
                              IsLottoBlocked = (x.LottiNC == null ? false : x.LottiNC.FlagBlocco)
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }


        public List<Lotto> GetLottiAll(long idpolvere)
        {
            List<Lotto> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere
                          orderby x.DataDdt, x.Giacenza descending
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              NoteCarico = (from m in context.Movimenti where m.IDLotto == x.IDLotto select m.Note).FirstOrDefault(),
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto> GetLotti()
        {
            List<Lotto> retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          orderby x.DataDdt
                          //where x.NumFattura == null && x.Giacenza > 0 && x.Tipo==1
                          where x.NumFattura == null //&& x.Giacenza > 0
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              IDPolvere = x.IDPolvere,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public double GetGiacenza(long idpolvere)
        {
            double retValue = 0;

            try
            {
                //where (x.IDPolvere == idpolvere && x.Giacenza > 0)
                var obj = (from x in context.Lotti
                           where x.IDPolvere == idpolvere
                           select (double?)x.Giacenza).Sum() ?? 0;

                //if (obj.Any())
                //{
                retValue = (double)obj;
                //}
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public long AddLotto(Lotto Lotto)
        {
            long retValue = 0;

            try
            {
                Lotti imp = new Lotti();

                imp.CodLotto = Lotto.CodLotto;
                imp.NumDdt = Lotto.NumDdt;
                imp.DataDdt = Lotto.DataDdt;
                imp.DataScadenzaLotto = Lotto.DataScadenzaLotto;
                imp.Giacenza = Lotto.Giacenza;
                imp.Valore = imp.Giacenza * Lotto.PrezzoUnitario;
                imp.PrezzoUnitario = Lotto.PrezzoUnitario;
                imp.Giacenza_iniziale = Lotto.Giacenza;
                imp.IDPolvere = Lotto.IDPolvere;
                imp.Tipo = 1;
                context.Lotti.AddObject(imp);
                context.SaveChanges();

                retValue = imp.IDLotto;
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public bool DeleteLotto(long idlotto)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == idlotto
                          select x;

                if (obj.Any())
                {
                    Lotti m_lotto = obj.FirstOrDefault();

                    context.Lotti.DeleteObject(m_lotto);
                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
            }

            return retValue;
        }

        public bool ModifyLotto(Lotto Lotto, double quantscar)
        {
            bool retValue = false;
            // 
            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == Lotto.IDLotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.CodLotto = Lotto.CodLotto;
                    imp.NumDdt = Lotto.NumDdt;
                    imp.DataDdt = Lotto.DataDdt;
                    imp.DataScadenzaLotto = Lotto.DataScadenzaLotto;
                    //imp.Giacenza = Lotto.Giacenza;
                    //imp.Giacenza_iniziale = Lotto.Giacenza;
                    imp.Giacenza_iniziale = Lotto.GiacenzaIniziale;
                    imp.Giacenza = imp.Giacenza_iniziale - quantscar;
                    imp.IDPolvere = Lotto.IDPolvere;

                    imp.PrezzoUnitario = Lotto.PrezzoUnitario;
                    imp.Valore = imp.PrezzoUnitario * imp.Giacenza;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public bool CheckIfLottoIsUserInScarico(long idLotto)
        {
            bool retValue = false;
            //  metodo non utilizzato non ho agiunto tipo=1

            var obj = from x in context.Movimenti
                      join cm in context.CausaliMagazzino on x.IDCausale equals cm.IDCausale
                      where x.IDLotto == idLotto && cm.CodCausale == "S"
                      select x;

            if (obj.Any())
            {
                retValue = true;
            }

            return retValue;
        }

        public bool UpdateFatturaInformations(Lotto Lotto)
        {
            bool retValue = false;
            // 
            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == Lotto.IDLotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.NumFattura = Lotto.NumFattura;
                    if (Lotto.DataFattura.HasValue)
                    {
                        imp.DataFattura = Lotto.DataFattura.Value;
                    }
                    //imp.PrezzoUnitario = Lotto.PrezzoUnitario.GetValueOrDefault();
                    imp.PrezzoUnitario = Lotto.PrezzoUnitario;
                    imp.Valore = Lotto.PrezzoUnitario * Lotto.Giacenza;
                    imp.QuantitaFatt = Lotto.QuantitaFatt;

                    imp.IDFattura = Lotto.IDFattura;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
                LastExceptionOccurred = ex;
                retValue = false;
            }

            return retValue;
        }

        public bool UpdateFatturaInformations(Lotto Lotto, List<CostoAggiuntivo> costiAggiuntivi)
        {
            bool retValue = false;
            // 
            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == Lotto.IDLotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.NumFattura = Lotto.NumFattura;
                    if (Lotto.DataFattura.HasValue)
                    {
                        imp.DataFattura = Lotto.DataFattura.Value;
                    }
                    //imp.PrezzoUnitario = Lotto.PrezzoUnitario.GetValueOrDefault();
                    imp.PrezzoUnitario = Lotto.PrezzoUnitario;
                    imp.Valore = Lotto.PrezzoUnitario * Lotto.Giacenza;
                    imp.QuantitaFatt = Lotto.QuantitaFatt;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
                LastExceptionOccurred = ex;
                retValue = false;
            }

            return retValue;
        }

        public bool AggLotto(long idlotto, double quantita)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == idlotto
                          select x;


                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.Giacenza = imp.Giacenza - quantita;
                    imp.Valore = imp.Giacenza * imp.PrezzoUnitario;

                    if (imp.Giacenza == 0)
                        imp.Tipo = 0;
                    else
                        imp.Tipo = 1;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                throw;
            }

            return retValue;
        }

        public bool AggDtCtrLotto(string codlotto, DateTime data)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.CodLotto == codlotto && x.Giacenza != 0
                          select x;

                foreach (Lotti l in obj.ToList())
                {
                    l.DataControllo = data;
                    //l.Tipo = (int)tipo;
                    retValue = true;
                }

                context.SaveChanges();
            }
            catch (Exception ex)
            {
            }

            return retValue;
        }

        public bool AggDtCtrPolvere(int idpolvere, DateTime data)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere && x.Giacenza != 0
                          select x;

                this.Transact(() =>
                {
                    foreach (Lotti l in obj.ToList())
                    {
                        l.DataControllo = data;
                        //l.Tipo = (int)tipo;
                    }
                }, this.context);

                retValue = true;
            }
            catch (Exception ex)
            {
            }

            return retValue;
        }

        public bool RipristinoLotto(long idlotto, double quantita)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == idlotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.Giacenza = imp.Giacenza + quantita;
                    imp.Valore = imp.Giacenza * imp.PrezzoUnitario;
                    if (imp.Giacenza == 0)
                        imp.Tipo = 0;
                    else
                        imp.Tipo = 1;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                throw;
            }

            return retValue;
        }

        public bool AggDatiFattura(long idlotto, long prezzo, string numFatt, DateTime dataFatt)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == idlotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.PrezzoUnitario = prezzo;
                    imp.NumFattura = numFatt;
                    imp.DataFattura = dataFatt;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
            }

            return retValue;
        }

        public Lotto GetLotto(string codlotto)
        {
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.CodLotto == codlotto
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public Lotto GetLotto(long idlotto)
        {
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == idlotto
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public Lotto GetDDT(string numddt, int fornitore, DateTime data)
        {
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.NumDdt == numddt && x.AnagPolveri.IDFornitore == fornitore && EntityFunctions.TruncateTime(x.DataDdt) == EntityFunctions.TruncateTime(data)
                          orderby x.DataDdt
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public bool CheckLottoPiuVecchio(long idPolvere, DateTime datalotto)
        {
            //metodo non utilizzato
            bool retValue = false;

            try
            {
                Lotti obj = (from x in context.Lotti
                             where x.Giacenza != 0 && x.IDPolvere == idPolvere
                             orderby x.DataDdt
                             select x).First();

                if (DateTime.Compare(obj.DataDdt, datalotto) == 0)
                {
                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public Lotto GetLottoPiuVecchio(string codlotto, double quantita)
        {
            // utilizzato solo nell'import--non aggiunto x.tipo==1
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.CodLotto == codlotto && x.Giacenza >= quantita
                          orderby x.DataDdt ascending
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
                else
                {
                    obj = from x in context.Lotti
                          where x.CodLotto == codlotto && x.Giacenza >= quantita
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                    if (obj.Any())
                    {
                        retValue = obj.FirstOrDefault();
                    }
                    else
                    {
                        obj = from x in context.Lotti
                              where x.CodLotto == codlotto
                              orderby x.DataDdt ascending
                              select new Lotto
                              {
                                  IDLotto = x.IDLotto,
                                  NumDdt = x.NumDdt,
                                  DataDdt = x.DataDdt,
                                  DataScadenzaLotto = x.DataScadenzaLotto,
                                  Giacenza = x.Giacenza,
                                  IDPolvere = x.IDPolvere,
                                  PrezzoUnitario = x.PrezzoUnitario,
                                  QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                              };

                        if (obj.Any())
                        {
                            retValue = obj.FirstOrDefault();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public Lotto GetUltimoCaricoLotto(string codlotto)
        {
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.CodLotto == codlotto
                          orderby x.DataDdt descending
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public Lotto GetUltimoCaricoPolvere(long idpolvere)
        {
            Lotto retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idpolvere
                          orderby x.DataDdt descending
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              NumDdt = x.NumDdt,
                              DataDdt = x.DataDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              IDPolvere = x.IDPolvere,
                              PrezzoUnitario = x.PrezzoUnitario,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt)
                          };

                if (obj.Any())
                {
                    retValue = obj.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public bool UpdateStatoMovimentazione(long idLotto, bool isMovimentato)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti where x.IDLotto == idLotto select x;

                if (obj.Any())
                {
                    Lotti l = obj.FirstOrDefault();
                    l.IsMovimentato = isMovimentato;

                    context.SaveChanges();
                }

                retValue = true;
            }
            catch (Exception ex)
            {
                throw;
            }

            return retValue;
        }

        public bool CheckStatoMovimentazione(long idLotto)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Movimenti
                          where x.IDLotto == idLotto && x.CausaliMagazzino.CodCausale == "S"
                          select x;

                if (!obj.Any())
                {
                    var obj2 = from ll in context.Lotti where ll.IDLotto == idLotto select ll;
                    Lotti m_lotto = obj2.FirstOrDefault();
                    m_lotto.IsMovimentato = false;

                    context.SaveChanges();
                }

                retValue = true;
            }
            catch (Exception ex)
            { }

            return retValue;
        }

        public bool CancellaAssociazione(Lotto item)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == item.IDLotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.NumFattura = null;
                    imp.DataFattura = null;
                    //imp.PrezzoUnitario = Lotto.PrezzoUnitario.GetValueOrDefault();
                    imp.PrezzoUnitario = 0;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public bool AnnullaDataControllo(Lotto item)
        {
            bool retValue = false;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDLotto == item.IDLotto
                          select x;

                if (obj.Any())
                {
                    Lotti imp = obj.FirstOrDefault();

                    imp.DataControllo = null;

                    context.SaveChanges();

                    retValue = true;
                }
            }
            catch (Exception ex)
            {
                // throw ex;
            }

            return retValue;
        }

        public List<Lotto> GetLottiByColore(int idColore)
        {
            List<Lotto> retValue = null;
            //  metodo non utilizzato - non aggiunto y.tipo==1
            var obj = from x in context.ComposizioneColori
                      join y in context.Lotti on x.IDPolvere equals y.IDPolvere
                      where x.IDColore == idColore
                      select new Lotto
                      {
                          IDLotto = y.IDLotto,
                          CodLotto = y.CodLotto,
                          DataDdt = y.DataDdt,
                          NumDdt = y.NumDdt,
                          DataScadenzaLotto = y.DataScadenzaLotto,
                          Giacenza = y.Giacenza,
                          GiacenzaIniziale = y.Giacenza_iniziale,
                          IDPolvere = y.IDPolvere,
                          NumFattura = y.NumFattura,
                          DataFattura = y.DataFattura,
                          CodicePolvere = y.AnagPolveri.CodicePolvere,
                          Fornitore = y.AnagPolveri.AnagFornitori.Descrizione,
                          PrezzoUnitario = y.PrezzoUnitario,
                          QuantitaFatt = (!y.QuantitaFatt.HasValue ? y.Giacenza_iniziale : y.QuantitaFatt),
                          IDFattura = y.IDFattura
                      };

            if (obj.Any())
            {
                retValue = obj.ToList();
            }

            return retValue;
        }

        public List<Lotto> GetLottiByPolvereList()
        {
            List<Lotto> retValue = null;
            // 
            var obj = from x in context.AnagPolveri
                      join y in context.Lotti on x.IDPolvere equals y.IDPolvere
                      //where y.Tipo==1
                      where y.Giacenza > 0
                      orderby x.CodicePolvere ascending
                      select new Lotto
                      {
                          IDLotto = y.IDLotto,
                          CodLotto = y.CodLotto,
                          DataDdt = y.DataDdt,
                          NumDdt = y.NumDdt,
                          DataScadenzaLotto = y.DataScadenzaLotto,
                          Giacenza = y.Giacenza,
                          GiacenzaIniziale = y.Giacenza_iniziale,
                          IDPolvere = y.IDPolvere,
                          NumFattura = y.NumFattura,
                          DataFattura = y.DataFattura,
                          CodicePolvere = y.AnagPolveri.CodicePolvere,
                          Fornitore = y.AnagPolveri.AnagFornitori.Descrizione,
                          PrezzoUnitario = y.PrezzoUnitario,
                          Valore = y.Valore,
                          DataControllo=y.DataControllo,
                          QuantitaFatt = (!y.QuantitaFatt.HasValue ? y.Giacenza_iniziale : y.QuantitaFatt),
                          IDFattura = y.IDFattura
                      };

            if (obj.Any())
            {
                retValue = obj.ToList();
            }

            return retValue;
        }

        public List<Lotto> GetLottiByFattura(long idFattura)
        {
            List<Lotto> retValue = null;
            // 
            var obj = from y in context.Lotti
                      where y.Giacenza > 0 && y.IDFattura == idFattura
                      orderby y.DataFattura descending
                      select new Lotto
                      {
                          IDLotto = y.IDLotto,
                          CodLotto = y.CodLotto,
                          DataDdt = y.DataDdt,
                          NumDdt = y.NumDdt,
                          DataScadenzaLotto = y.DataScadenzaLotto,
                          Giacenza = y.Giacenza,
                          GiacenzaIniziale = y.Giacenza_iniziale,
                          IDPolvere = y.IDPolvere,
                          NumFattura = y.NumFattura,
                          DataFattura = y.DataFattura,
                          CodicePolvere = y.AnagPolveri.CodicePolvere,
                          Fornitore = y.AnagPolveri.AnagFornitori.Descrizione,
                          PrezzoUnitario = y.PrezzoUnitario,
                          Valore = y.Valore,
                          DataControllo = y.DataControllo,
                          QuantitaFatt = (!y.QuantitaFatt.HasValue ? y.Giacenza_iniziale : y.QuantitaFatt),
                          IDFattura = y.IDFattura
                      };

            if (obj.Any())
            {
                retValue = obj.ToList();
            }

            return retValue;
        }

        public DateTime? GetDataControllo(long idPolvere)
        {
            DateTime? retValue = null;

            try
            {
                var obj = from x in context.Lotti
                          where x.IDPolvere == idPolvere && x.DataControllo == null && x.Giacenza != 0
                          select x;

                if (obj.Any())
                {
                    retValue = null;
                }
                else
                {
                    var obj2 = (from ll in context.Lotti where ((ll.IDPolvere == idPolvere) && (ll.Giacenza !=0)) orderby ll.DataControllo descending select ll.DataControllo).FirstOrDefault();

                    retValue = obj2.Value;
                }

            }
            catch (Exception ex)
            { }

            return retValue;
        }

        public List<Lotto> GetLottiOrfani()
        {
            List<Lotto> retValue = null;

            try
            {
                //SELECT GP.Lotti.CodLotto, GP.Lotti.NumDdt, GP.Lotti.DataDdt, GP.Lotti.IsMovimentato
                //FROM   GP.Lotti 
                //LEFT OUTER JOIN GP.Movimenti ON GP.Lotti.IDLotto = GP.Movimenti.IDLotto
                //WHERE (GP.Movimenti.IDLotto IS NULL)
                //ORDER BY GP.Lotti.CodLotto


                var obj = from x in context.Lotti
                          join y in context.Movimenti on x.IDLotto equals y.IDLotto into x_y
                          from y in x_y.DefaultIfEmpty()
                          where y.IDLotto == null
                          select new Lotto
                          {
                              IDLotto = x.IDLotto,
                              CodLotto = x.CodLotto,
                              DataDdt = x.DataDdt,
                              NumDdt = x.NumDdt,
                              DataScadenzaLotto = x.DataScadenzaLotto,
                              Giacenza = x.Giacenza,
                              GiacenzaIniziale = x.Giacenza_iniziale,
                              IDPolvere = x.IDPolvere,
                              NumFattura = x.NumFattura,
                              DataFattura = x.DataFattura,
                              CodicePolvere = x.AnagPolveri.CodicePolvere,
                              Fornitore = x.AnagPolveri.AnagFornitori.Descrizione,
                              PrezzoUnitario = x.PrezzoUnitario,
                              Valore = x.Valore,
                              DataControllo = x.DataControllo,
                              QuantitaFatt = (!x.QuantitaFatt.HasValue ? x.Giacenza_iniziale : x.QuantitaFatt),
                              IDFattura = x.IDFattura
                          };

                if (obj.Any())
                {
                    retValue = obj.ToList();
                }
            }
            catch (Exception ex)
            { 
            }

            return retValue;
        }

        public static Fattura GetFattura(Lotto item)
        {
            Fattura retValue = new Fattura();

            if (string.IsNullOrWhiteSpace(item.NumFattura))
            {
                throw new Exception("Numero Fattura non disponibile. Salvataggio interrotto !\nVerificare di aver inserito correttamente il numero fattura !");
            }

            retValue.ID = item.IDFattura.GetValueOrDefault(-1);
            retValue.Numero = item.NumFattura;
            retValue.Data = item.DataFattura.GetValueOrDefault();
            
            return retValue;
        }

        public LottoNCInfo CheckIfNC(long idLotto)
        {
            LottoNCInfo retValue = null;

            var obj = from x in context.LottiNC
                          where x.IDLotto == idLotto
                          select x;

            if (obj.Any())
            {
                LottiNC m_lotto = obj.FirstOrDefault();

                retValue = new LottoNCInfo();
                retValue.IDOperatore = m_lotto.IDOperatore;
                retValue.IDLotto = m_lotto.IDLotto;
                retValue.IsLottoBloccato = m_lotto.FlagBlocco;
                retValue.IsLottoNC = m_lotto.FlagNC;
                retValue.Note = m_lotto.Note;
            }

            return retValue;
        }
    }
}
